Computer software comprises a set of instructions to be executed by a data processing system. Generally, it is the computer software which makes a data processing system useful, by providing the instructions for the data processing system to carry out productive tasks. Computer software provides instructions that enable a data processing system to function as, for example, a word processing device, spreadsheet device, or an Internet browsing device.
There are a wide variety of different data processing systems capable of using computer software. Accordingly, as used herein, the term “data processing system” is intended to have a broad meaning, and may include personal computers, laptop computers, palmtop computers, handheld computers, network computers, servers, mainframes, workstations, cellular telephones and similar wireless devices, personal digital assistants and other electronic devices on which computer software may be installed. The terms “computer”, “computer software”, “computer program”, “computer programming”, “software”, “software program” and related terms are intended to have a similarly broad meaning.
Generally, modern computer software is originally written in a computer programming language using syntactic constructs that are comprehensible by a programmer to represent the instructions embodied in the software. For example, in the “C” programming language, the syntactic term “printf” is used to represent an instruction to the data processing system to print the contents of a particular data field. These types of computer programming languages are useful because their syntactic constructs make it easier for programmers to create computer software, since they do not need to compose instructions in a language that would be directly understood by the data processing system. Writing instructions in such a language would be far more difficult because such languages bear little or no resemblance to any human language. A computer program, or a portion thereof, written with such a human-comprehensible programming language is generally referred to as “source code”. Software developers can create source code either by directly authoring the source code (for example by entering the instructions into a text editor), or, more recently, by using specialized software programs that provide a specially designed user interface and that partially or substantially automate the generation of source code.
Instructions written in human-comprehensible source code, however, generally cannot be directly understood and implemented by a data processing system. Therefore, before a computer program written in human-comprehensible computer programming language (i.e. source code) may be used by a data processing system, it must first be “compiled” into language that will be understood by the target data processing system. Compiling is a process, usually carried out by a computer program called a “compiler”, in which the syntactic constructs of the human-comprehensible computer programming language are in essence translated into instructions in a language that will be understood by the target data processing system (possibly through an intermediate software layer). The result of the “compiling” or “compilation” process is known as “executable code”, meaning computer program code that can be executed by the data processing system either directly or by an intermediate software layer. Executable code is generally platform-specific, meaning that it can only be executed by a specific type of computer system. Accordingly, source code must generally be compiled in a specific way to be executed by a given type of computer.
For certain computer programming languages, such as Java™, the source code is first compiled into an intermediate form that can be implemented by an intermediate software layer, such as a Java virtual machine (hereinafter “JVM”). In Java, this intermediate form is known as “bytecode”. (Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.) Typically, but not necessarily, the intermediate software layer will carry out additional compilation each time the computer program is run, usually to translate the intermediate form of the source code into executable code that can be directly executed by the data processing system. While the JVM itself is platform-specific, it enables any computer having a compatible JVM to execute a Java program that has been compiled into bytecode, without the Java program having to have been compiled in a platform-specific way.
Software developers, being human, are not perfect. As a result, when software developers create or modify computer programs, these programs frequently contain errors which cause the program to perform in a manner that was not intended. These errors are referred to as “bugs”, and the process of identifying and correcting these errors is referred to as “debugging”.
Originally, it was necessary for the software developer to make the correction in the source code, and then compile the entire source code program into executable code. This process of correcting errors in the source code and then compiling the entire program again is time consuming, particularly where only a single file needs to be modified.
In modern programming systems, debuggers are used to assist programmers in locating problems in their programs by enabling the setting of breakpoints in the code, and allowing the user to view and alter variables dynamically. More advanced systems allow users to modify their programs as they are debugging them, with the modified program replacing the original instantaneously. Such a feature is called “Hot Code Replace” (hereinafter “HCR”). In particular, a software developer would use a computer program known as an application development tool, usually having a graphical user interface (hereinafter “GUI”), to modify the software program that is being debugged. The application development tool is configured so that it can, in response to the developer's changes, build a single unit of code (e.g. a Java class) embodying those changes without having to rebuild the entire program. The original code unit is then replaced with the new code unit incorporating the developer's changes. An example of such a system is the Eclipse programming environment running with a compatible JVM. Unfortunately, this HCR feature is limited by the environment to Java programs only.
HCR could be very useful for high-level languages and visual paradigms such as BPEL (Business Processing Execution Language), Message Flows, Data Maps, Business Rules, and the like. As used herein, the term “high-level language” refers to a language wherein the operations and data structures denoted in the language are strongly related to a problem domain, such as, for example, business processes. Because of this, such languages may be relatively difficult to compile directly into executable code, and these languages and systems therefore often have their own specialized intermediate software layer (or “engine”) for executing programs written in that language. Typically, the specialized intermediate software layer will generate instructions in a “base language” (e.g. Java) that will then be interpreted by an underlying intermediate software layer (e.g. a JVM) so as to cause the computer to implement the instructions embodied in source code written in the high-level language. As used herein, the term “base language” refers to a language wherein the operations and data structures denoted in the language are strongly related to machine-level concepts. Base languages are therefore relatively easy to compile into executable code. For clarity, intermediate software layers used to execute programs written in high-level languages will be referred to herein as “engines” (as noted above), so as to distinguish them from the underlying intermediate software layer for the “base language”.
Unfortunately, the engines for high-level languages are frequently incompatible with the HCR functionality provided by the intermediate software layer for the lower level base language. Therefore, when using such high-level languages, a software developer often has to use the old method of changing the source code, compiling the program again, and then re-running the program to see the changes take effect. Even if the engine for the relevant high-level language could support HCR, it would be necessary to provide a mechanism to deliver changed programs to the intermediate software layer so that they could be incorporated into running system.